#include <iostream>
#include <string.h>

using namespace std;

// void x(int&& x1)
// {
//     printf("%p\n",&x1);
// }

// int main()
// {
//     x(1);
//     x(100);
//     // printf("%p\n",&1);
//     // printf("%p\n",&x100);
//     return 0;
// }









void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

// 引用
// 传左值->左值引用
// 传右值->右值引用
template<typename T>
void PerfectForward(T&& t)
{
	// 模版实例化是左值引用，保持属性直接传参给Fun
	// 模版实例化是右值引用，右值引用属性会退化成左值，转换成右值属性再传参给Fun
	Fun(forward<T>(t));
}

// void PerfectForward(int& t)
// {
// 	Fun(t);
// }

// void PerfectForward(int&& t)
// {
// 	Fun(move(t));
// }

// void PerfectForward(const int& t)
// {
// 	Fun(t);
// }

// void PerfectForward(const int&& t)
// {
// 	Fun(move(t));
// }

// int main()
// {
// 	PerfectForward(10);           // 右值

// 	int a;
// 	PerfectForward(a);            // 左值

// 	PerfectForward(std::move(a)); // 右值

// 	const int b = 8;
// 	PerfectForward(b);			  // const 左值
// 	PerfectForward(std::move(b)); // const 右值

// 	return 0;
// }









// class Person
// {
// public:
// 	Person(const char* name = "111111111111", int age = 0)
// 		:_name(name)
// 		, _age(age)
// 	{}

// 	Person(Person&& p) = default;
// 	Person& operator=(Person && p) = default;
// 	Person(const Person& p) = default;
// 	Person& operator=(const Person& p) = default;

// 	// 自动生成拷贝构造和移动构造
// 	~Person()
// 	{}
// private:
// 	string _name;
// 	int _age;
// };


// int main()
// {
// 	Person s1;
// 	Person s2 = s1;
// 	Person s3 = std::move(s1);

// 	Person s4;
// 	s4 = std::move(s2);

// 	return 0;
// }










// class Person
// {
// public:
// 	Person(const char* name = "111111111111", int age = 0)
// 		:_name(name)
// 		, _age(age)
// 	{}

//     //C++11
//     Person(const Person& p) = delete;
// 	Person& operator=(const Person & p) = delete;



// 	// 只声明不实现，声明为私有
// 	// C++98
// //private:
// //	Person(const Person& p);
// //	Person& operator=(const Person & p);

// 	Person(const Person& p) = delete;
// 	Person& operator=(const Person& p) = delete;
// private:
//     string _name;
// 	int _age;
// };









/////////////////////////////////////////////////
//template <class ...Args>
//void ShowList(Args... args)
//{}
//
//template <class ...T>
//void ShowList1(T... x)
//{}
//
//template <class ...Args>
//void ShowList2(Args&&... args)
//{}
//
//int main()
//{
//
//
//	return 0;
//}






// 可变模版参数
// 参数类型可变
// 参数个数可变
// 打印参数包内容
// template <class ...Args>
// void ShowList(Args... args)
// {
// 	// 可变参数模版编译时解析
// 	// 下面是运行获取和解析，所以不支持这样用
// 	cout << sizeof...(args) << endl;
// 	for (size_t i = 0; i < sizeof...(args); i++)
// 	{
// 		cout << args[i] << " ";
// 	}
// 	cout << endl;
// }




// void Print()
// {
// 	cout << endl;
// }

// template <class T, class ...Args>
// void Print(T&& x, Args&&... args)
// {
// 	cout << x << " ";
// 	Print(args...);
// }

// // 编译时递归推导解析参数
// template <class ...Args>
// void ShowList(Args&&... args)
// {
// 	Print(args...);
// }

// int main()
// {
// 	ShowList();
// 	ShowList(1);
// 	ShowList(1, "xxxxx");
// 	ShowList(1, "xxxxx", 2.2);

// 	return 0;
// }






// void Print()
// {
// 	cout << endl;
// }

// template <class T, class ...Args>
// void Print(T&& x, Args&&... args)
// {
// 	cout << x << " ";
// 	Print(args...);
// }

// // 编译器推导的
// void Print(double x)
// {
// 	cout << x << " ";
// 	Print();
// }

// void Print(const char* x, double z)
// {
// 	cout << x << " ";
// 	Print(z);
// }

// void Print(int x, const char* y, double z)
// {
// 	cout << x << " ";
// 	Print(y, z);
// }

// // 编译时递归推导解析参数
// template <class ...Args>
// void ShowList(Args&&... args)
// {
// 	Print(args...);
// }
// // 编译器实例化生成
// void ShowList(int x, const char* y, double z)
// {
// 	Print(x, y, z);
// }

// int main()
// {
// 	ShowList(1, "xxxxx", 2.2);

// 	return 0;
// }





/////////////////////////////////////////////////////////////////////
// template <class T>
// int PrintArg(T t)
// {
// 	cout << t << " ";
// 	return 0;
// }

// template <class ...Args>
// void ShowList(Args... args)
// {
// 	int arr[] = { PrintArg(args)... };
// 	cout << endl;
// }

// // 编译推演生成下面的函数
// // void ShowList(int x, char y, std::string z)
// // {
// // 	int arr[] = { PrintArg(x),PrintArg(y),PrintArg(z) };
// // 	cout << endl;
// // }

// int main()
// {
// 	//ShowList(1);
// 	//ShowList(1, 'A');
// 	ShowList(1, 'A', std::string("sort"));

// 	return 0;
// }





// template <class ...Args>
// void ShowList(Args... args)
// {
// 	int arr[] = { (cout<<(args)<<" ", 0)...};

// 	cout << endl;
// }

// void ShowList(int x, char y, std::string z)
// {
// 	int arr[] = { (cout<<(x)<<" ", 0), (cout << (y) << " ", 0), (cout << (z) << " ", 0) };

// 	cout << endl;
// }

// int main()
// {
// 	ShowList(1, 'A', std::string("sort"));

// 	return 0;
// }






// #include <iostream>

// using namespace std;

// int main() {
//     int arr[3] = {1, 2, 3};
    
//     auto x = arr; // x 推导为 int*（数组名退化）

// 	// for(auto e:x)
// 	// {
// 	// 	cout << e << " ";
// 	// }
// 	// cout << endl;

//     std::cout << typeid(x).name() << std::endl; // 输出：int*（因编译器而异）
    
//     x[0] = 10; // 可通过指针访问数组元素
// 	x[1] = 11;
//     std::cout << arr[0] << std::endl; // 输出 10
// 	std::cout << arr[1] << std::endl; // 输出 11

//     return 0;
// }











#include "List.h"
#include <string.h>
#include <algorithm>

namespace ltw
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}

		typedef const char* const_iterator;
		const_iterator begin() const
		{
			return _str;
		}

		const_iterator end() const
		{
			return _str + _size;
		}

		string(const char* str = "")
			:_size(strlen(str))
			, _capacity(_size)
		{
			cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1];
			strcpy(_str, str);
		}

		// s1.swap(s2)
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}

		// 拷贝构造
		// s2(s1)
		string(const string& s)
			:_str(nullptr)
		{
			cout << "string(const string& s) -- deepcopy" << endl;

			reserve(s._capacity);
			for (auto ch : s)
			{
				push_back(ch);
			}
		}
		

		// 移动构造
		// 临时创建的对象，不能取地址，用完就要消亡
		// 深拷贝的类，移动构造才有意义
		string(string&& s)
		{
			cout << "string(string&& s) -- movecopy" << endl;
			swap(s);
		}

		// 赋值重载
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- deepcopy" << endl;
			if (this != &s)
			{
				_str[0] = '\0';
				_size = 0;

				reserve(s._capacity);
				for (auto ch : s)
				{
					push_back(ch);
				}
			}

			return *this;
		}

		// 移动赋值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- move=" << endl;

			swap(s);
			return *this;
		}

		~string()
		{
			delete[] _str;
			_str = nullptr;
		}

		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}

		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				if (_str)
				{
					strcpy(tmp, _str);
					delete[] _str;
				}
				_str = tmp;
				_capacity = n;
			}
		}

		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}

			_str[_size] = ch;
			++_size;
			_str[_size] = '\0';
		}

		//string operator+=(char ch)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}

		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str = nullptr;
		size_t _size = 0;
		size_t _capacity = 0; // 不包含最后做标识的\0
	};

	ltw::string to_string(int value)
	{
		bool flag = true;
		if (value < 0)
		{
			flag = false;
			value = 0 - value;
		}
		ltw::string str;

		while (value > 0)
		{
			int x = value % 10;
			value /= 10;
			str += ('0' + x);
		}

		if (flag == false)
		{
			str += '-';
		}

		std::reverse(str.begin(), str.end());

		return str;
	}
}
#include <list>

// emplace_back总体而言是更高效，推荐使用
int main()
{
	list<ltw::string> lt;
	// 左值
	ltw::string s1("111111111111");
	lt.emplace_back(s1);

	// 右值
	lt.emplace_back(move(s1));

	// 直接把构造string参数包往下传，直接用string参数包构造string
	lt.emplace_back("111111111111");
	lt.emplace_back(10, 'x');
	cout << endl << endl;

	list<pair<ltw::string, int>> lt1;
	// 构造pair + 拷贝/移动构造pair到list的节点中data上
	pair<ltw::string, int> kv("苹果", 1);
	lt1.emplace_back(kv);
	lt1.emplace_back(move(kv));
	cout << endl << endl;

	////////////////////////////////////////////////////////////////////
	// 直接把构造pair参数包往下传，直接用pair参数包构造pair
	lt1.emplace_back("苹果", 1);

	return 0;
}





